"""
留言管理API路由
"""
from datetime import datetime, date
from typing import Optional, List
from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.orm import Session
from sqlalchemy import func, desc, and_
import math

from ..database import get_db
from ..models.message import Message
from ..models.user import User
from ..schemas.message import (
    MessageCreate, MessageUpdate, MessageResponse, 
    MessageListResponse, MessageStatsResponse
)
from ..dependencies import get_current_active_user

router = APIRouter(prefix="/api/messages", tags=["留言管理"])

@router.post("", response_model=MessageResponse, summary="提交留言")
async def create_message(
    message_data: MessageCreate,
    db: Session = Depends(get_db)
):
    """
    提交留言（公开接口，无需认证）
    
    用户在前台联系页面提交留言
    """
    # 创建留言对象
    db_message = Message(**message_data.dict())
    
    # 保存到数据库
    db.add(db_message)
    db.commit()
    db.refresh(db_message)
    
    return db_message

@router.get("", response_model=MessageListResponse, summary="获取留言列表")
async def get_messages(
    page: int = Query(1, ge=1, description="页码"),
    size: int = Query(10, ge=1, le=100, description="每页数量"),
    keyword: Optional[str] = Query(None, description="搜索关键词"),
    is_read: Optional[bool] = Query(None, description="是否已读"),
    is_replied: Optional[bool] = Query(None, description="是否已回复"),
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """
    获取留言列表（需要管理员权限）
    
    支持搜索和筛选
    """
    # 构建基础查询
    query = db.query(Message)
    
    # 搜索关键词（在姓名、电话、邮箱、主题、留言内容中搜索）
    if keyword:
        search_filter = func.or_(
            Message.name.contains(keyword),
            Message.phone.contains(keyword),
            Message.email.contains(keyword),
            Message.subject.contains(keyword),
            Message.message.contains(keyword)
        )
        query = query.filter(search_filter)
    
    # 筛选条件
    if is_read is not None:
        query = query.filter(Message.is_read == is_read)
    
    if is_replied is not None:
        query = query.filter(Message.is_replied == is_replied)
    
    # 排序：未读优先，然后按创建时间倒序
    query = query.order_by(Message.is_read.asc(), desc(Message.created_at))
    
    # 计算总数
    total = query.count()
    
    # 分页
    offset = (page - 1) * size
    messages = query.offset(offset).limit(size).all()
    
    # 计算总页数
    pages = math.ceil(total / size) if total > 0 else 1
    
    return MessageListResponse(
        items=messages,
        total=total,
        page=page,
        size=size,
        pages=pages
    )

@router.get("/stats", response_model=MessageStatsResponse, summary="获取留言统计")
async def get_message_stats(
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """
    获取留言统计信息（需要管理员权限）
    """
    # 总留言数
    total = db.query(Message).count()
    
    # 未读留言数
    unread = db.query(Message).filter(Message.is_read == False).count()
    
    # 未回复留言数
    unreplied = db.query(Message).filter(Message.is_replied == False).count()
    
    # 今日新增留言数
    today = date.today()
    today_count = db.query(Message).filter(
        func.date(Message.created_at) == today
    ).count()
    
    return MessageStatsResponse(
        total=total,
        unread=unread,
        unreplied=unreplied,
        today=today_count
    )

@router.get("/{message_id}", response_model=MessageResponse, summary="获取留言详情")
async def get_message(
    message_id: int,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """获取留言详情（需要管理员权限）"""
    message = db.query(Message).filter(Message.id == message_id).first()
    
    if not message:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="留言不存在"
        )
    
    # 标记为已读
    if not message.is_read:
        message.is_read = True
        db.commit()
        db.refresh(message)
    
    return message

@router.put("/{message_id}", response_model=MessageResponse, summary="更新留言")
async def update_message(
    message_id: int,
    message_data: MessageUpdate,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """
    更新留言（需要管理员权限）
    
    主要用于标记已读、已回复状态和添加回复内容
    """
    # 查找留言
    db_message = db.query(Message).filter(Message.id == message_id).first()
    
    if not db_message:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="留言不存在"
        )
    
    # 更新字段
    update_data = message_data.dict(exclude_unset=True)
    
    # 如果添加了回复内容，自动设置回复时间和已回复状态
    if "reply_content" in update_data and update_data["reply_content"]:
        update_data["is_replied"] = True
        update_data["reply_time"] = datetime.now()
    
    for field, value in update_data.items():
        setattr(db_message, field, value)
    
    # 保存更改
    db.commit()
    db.refresh(db_message)
    
    return db_message

@router.delete("/{message_id}", summary="删除留言")
async def delete_message(
    message_id: int,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """删除留言（需要管理员权限）"""
    # 查找留言
    db_message = db.query(Message).filter(Message.id == message_id).first()
    
    if not db_message:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="留言不存在"
        )
    
    # 删除留言
    db.delete(db_message)
    db.commit()
    
    return {"message": "留言删除成功"}

@router.post("/{message_id}/mark-read", response_model=MessageResponse, summary="标记留言为已读")
async def mark_message_read(
    message_id: int,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """标记留言为已读（需要管理员权限）"""
    message = db.query(Message).filter(Message.id == message_id).first()
    
    if not message:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="留言不存在"
        )
    
    message.is_read = True
    db.commit()
    db.refresh(message)
    
    return message

@router.post("/mark-all-read", summary="标记所有留言为已读")
async def mark_all_messages_read(
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """标记所有留言为已读（需要管理员权限）"""
    # 更新所有未读留言
    updated_count = db.query(Message).filter(
        Message.is_read == False
    ).update({"is_read": True})
    
    db.commit()
    
    return {"message": f"已标记 {updated_count} 条留言为已读"}
